package codem;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 参考：https://blog.csdn.net/tredemere/article/details/52815965
 * 题目描述
 * 小美和小团最近沉迷可乐。可供TA们选择的可乐共有k种，比如可口可乐、零度可乐等等，每种可乐会带给小美和小团不同的快乐程度。
 * TA们一共要买n瓶可乐，每种可乐可以买无限多瓶，小美会随机挑选其中的m瓶喝，剩下的n-m瓶小团喝。
 * 请问应该如何购买可乐，使得小美和小团得到的快乐程度的和的期望值最大？
 * 现在请求出购买可乐的方案。
 * 输入描述:
 * 第一行三个整数n，m，k分别表示要买的可乐数、小美喝的可乐数以及可供选择的可乐种数。
 * 接下来k行，每行两个整数a，b分别表示某种可乐分别给予小美和小团的快乐程度。
 * 对于所有数据，1 <= n <= 10,000, 0 <= m <= n, 1 <= k <= 10,000, -10,000 <= a, b <= 10,000
 * 输出描述:
 * 一行k个整数，第i个整数表示购买第i种可乐的数目。
 * 如果有多解，请输出字典序最小的那个。
 * 对于两个序列 a1, a2, ..., ak, b1, b2, ..., bk，a的字典序小于b，当且仅当存在一个位置i <= k满足：
 * ai < bi且对于所有的位置 j < i，aj = bj；
 * 示例1
 * 输入
 * <p>
 * 2 1 2
 * 1 2
 * 3 1
 * 输出
 * <p>
 * 0 2
 * 说明
 * <p>
 * 一共有三种购买方案：
 * 1. 买2瓶第一类可乐，小美和小团各喝一瓶，期望得到的快乐程度和为1+2=3；
 * 2. 买1瓶第一类可乐和1瓶第二类可乐，小美和小团各有二分之一的概率喝到第一类可乐，另有二分之一的概率喝到第二类可乐，
 * 期望得到的快乐程度和为1*0.5+3*0.5+2*0.5+1*0.5=3.5；
 * 3. 买2瓶第二类可乐，小美和小团各喝一瓶，期望得到的快乐程度和为3+1=4。
 */
public class Solution1 {

    //public static void main(String[] args) {
    //    Integer[] chs = {1, 2, 3};
    //    per(new Integer[3], chs, 3 - 1);
    //}

    private static BigDecimal max = new BigDecimal(Integer.MIN_VALUE);
    private static List<Integer> res = new ArrayList<>();

    public static void per(Integer[] buf, Integer[] chs, int len, int n, int m, List<Integer[]> items) {
        if (len == -1) {
            BigDecimal curMax = BigDecimal.ZERO;
            for (int i = buf.length - 1; i >= 0; --i) {
                Integer[] each = items.get(buf[i]);
                BigDecimal cur = new BigDecimal(m).divide(new BigDecimal(n), 3, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(each[0]))
                        .add(new BigDecimal(n - m).divide(new BigDecimal(n), 3, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(each[1])));
                curMax = curMax.add(cur);
            }
            if (max.doubleValue() <= curMax.doubleValue()) {
                max = curMax;
                res.clear();
                for (int i = buf.length - 1; i >= 0; --i) {
                    res.add(buf[i]);
                }
            }
            return;
        }
        for (int i = 0; i < chs.length; i++) {
            buf[len] = chs[i];
            per(buf, chs, len - 1, n, m, items);
        }
    }

    private static int[] calcMax(int n, int m, List<Integer[]> items) {
        Integer[] chs = new Integer[items.size()];
        for (int i = 0; i < chs.length; i++) {
            chs[i] = i;
        }
        per(new Integer[n], chs, n - 1, n, m, items);

        int[] result = new int[items.size()];
        for (Integer re : res) {
            result[re] += 1;
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();
        List<Integer[]> items = new ArrayList<>();
        List<Integer> indexs = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            Integer[] item = {sc.nextInt(), sc.nextInt()};
            if (i != 0) {
                int before = items.get(items.size() - 1)[0] + items.get(items.size() - 1)[1];
                int current = item[0] + item[1];
                if (before < current) {
                    indexs.clear();
                    indexs.add(i);
                    items.clear();
                    items.add(item);
                } else if (before == current) {
                    indexs.add(i);
                    items.add(item);
                } else {
                    continue;
                }
            } else {
                indexs.add(i);
                items.add(item);
            }
        }
        int[] result = calcMax(n, m, items);

        int index = 0;
        for (int i = 0; i < k; i++) {
            if (i == k - 1) {
                if (indexs.contains(i)) {
                    System.out.println(result[index++]);
                } else {
                    System.out.println(0);
                }
            }else {
                if (indexs.contains(i)) {
                    System.out.print(result[index++] + " ");
                } else {
                    System.out.print("0 ");
                }
            }
        }
    }
}
